/*
 * colas.c
 *
 *  Created on: 27/09/2011
 *      Author: utn_so
 */

#include "algoritmoPPD.h"

/*
 cola CREAR() {
 cola C = NULL;
 t_sector *sector = NULL;
 sector = (t_sector*)malloc(sizeof(t_sector));
 C = (nodo *) malloc(sizeof(nodo));
 sector->type = 0;
 sector->numero = -1;
 sector->datos[0] = '\0';
 C->elemento = *sector;
 C->siguiente = NULL;
 return C;
 }
 */

/* typedef struct Nodo {
 int elemento;
 struct Nodo *siguiente;
 } nodo;
 Cola var_cola;

 typedef nodo* Cola; */
uint32_t extremo_superior_ascendente = 0;
uint32_t extremo_superior_descendente = 0;
// uint32_t posActualCabezal = 0;
uint32_t extremo_inferior_descendente = 0;
uint32_t extremo_inferior_ascendente = 0;
uint32_t primer_sector = 0;

void PONER_EN_COLA_SSTF(t_sector sector, cola C)

{
	cola Cola;
	Cola = C;
	if ((*Cola) == NULL) {
		(*Cola) = (primero) malloc(sizeof(primero));
		(*Cola)->elemento = sector;
		(*Cola)->siguiente = NULL;
	} else {
		cola actual = NULL;
		primero ptr = NULL;
		actual = Cola;
		if (((*actual)->siguiente) != NULL) {
			while (abs((*actual)->elemento.numero - sector.numero)
					> abs(
							(*actual)->siguiente->elemento.numero
									- (*actual)->elemento.numero)) {
				(*actual) = (*actual)->siguiente;
				if (((*actual)->siguiente) == NULL
				)
					break;
			}
			if (((*actual)->siguiente) != NULL) {
				if (abs((*actual)->elemento.numero - sector.numero)
						== abs(
								(*actual)->siguiente->elemento.numero
										- (*actual)->elemento.numero)) {
					(*actual) = (*actual)->siguiente; // Si la cercania es igual decide por FIFO
				}
			}
		}
		ptr = (primero) malloc(sizeof(primero));
		ptr->elemento = sector;
		ptr->siguiente = (*actual)->siguiente;
		(*actual)->siguiente = ptr;
	}

}

/*void ORDENAR_ASCENDENTE_FSCAN(t_sector  sector, cola C1, cola C2) {
 nodo *actual, *ptr;
 actual = C2;
 t_sector sect_final.numero=199;

 if (extremo_superior_ascendente < 1) {
 ptr = (nodo *) malloc(sizeof(nodo));
 ptr->elemento = sect_final;
 ptr->siguiente = actual->siguiente;
 actual->siguiente = ptr;
 extremo_superior_ascendente++;
 }
 actual = C2;
 if ((sector.numero) < (actual->elemento.numero))
 {
 ptr = (nodo *) malloc(sizeof(nodo));
 ptr->elemento = actual->elemento;
 ptr->siguiente=actual->siguiente;
 actual->elemento=sector;
 actual->siguiente=ptr;

 }
 else {
 while (actual->siguiente->elemento.numero < sector.numero) {actual = actual->siguiente;}
 ptr = (nodo *) malloc(sizeof(nodo));
 ptr->elemento= sector;
 ptr->siguiente = actual->siguiente;
 actual->siguiente = ptr;}

 }*/

/*void ORDENAR_DESCENDENTE_FSCAN (t_sector sector , cola C1 , cola C2)
 { nodo *actual,*ptr;
 actual=C1;
 t_sector sect_inicial=0;



 if (extremo_inferior_descendente<1){
 ptr = (nodo *) malloc(sizeof(nodo));
 ptr->elemento = sect_inicial;
 ptr->siguiente = actual->siguiente;
 actual->siguiente = ptr;
 extremo_inferior_descendente++;
 }
 actual=C1;
 if ( (actual->elemento.numero - sector.numero)<0)

 { //aca lo deberia ordenar en la cola 2 o cola_ascendente de forma ascendente
 if (primer_sector < 1)
 {
 INSERTAR_PRIMERO(sector, C2);
 primer_sector++;
 }
 else{ORDENAR_ASCENDENTE_FSCAN(sector,C1,C2);}
 }
 else {
 actual=C1;
 while (actual->siguiente->elemento.numero > sector.numero)
 {actual=actual->siguiente;}
 ptr = (nodo *) malloc(sizeof(nodo));
 ptr->elemento= sector;
 ptr->siguiente = actual->siguiente;
 actual->siguiente = ptr;
 }
 }

 void INSERTAR_PRIMERO(t_sector sector, cola C)

 {
 C->elemento=sector.numero;
 }*/

void QUITAR_DE_COLA(t_sector *sector, cola C) {
	primero actual = NULL;
//	aux = NULL;
//	aux = (cola) malloc (sizeof(cola));
	if (*C != NULL)
	{
		actual = *C;
		*sector = (*C)->elemento;
		(*C) = (actual)->siguiente;
	}
	(actual)->siguiente = NULL;
	free(actual);
	actual = NULL;
}

/*void DESTRUIR(cola C)

 {
 while (!VACIA(C))
 QUITAR_DE_COLA(C);
 free(C->ant);
 free(C);
 }*/
